function Array_h (length) {
  this.array = length === undefined ? [] : new Array(length)
}

Array_h.prototype = {
      /**
       * 返回数组长度
       *
       * @return {Number} length [数组长度]
       */
  length: function () {
    return this.array.length
  },

  at: function (index) {
    return this.array[index]
  },

  set: function (index, obj) {
    this.array[index] = obj
  },

      /**
       * 向数组的末尾添加一个或多个元素，并返回新的长度。
       *
       * @param  {*} obj [description]
       * @return {Number} length [新数组的长度]
       */
  push: function (obj) {
    return this.array.push(obj)
  },

      /**
       * 返回数组中选定的元素
       *
       * @param  {Number} start [开始索引值]
       * @param  {Number} end [结束索引值]
       * @return {Array} newArray  [新的数组]
       */
  slice: function (start, end) {
    return this.array = this.array.slice(start, end)
  },

  concat: function (array) {
    this.array = this.array.concat(array)
  },

  remove: function (index, count) {
    count = count === undefined ? 1 : count
    this.array.splice(index, count)
  },

  join: function (separator) {
    return this.array.join(separator)
  },

  clear: function () {
    this.array.length = 0
  }
}

  /**
   * 先进先出队列 (First Input First Output)
   *
   * 一种先进先出的数据缓存器
   */
var Queue = function () {
  this._array_h = new Array_h()
}

Queue.prototype = {
  _index: 0,

      /**
       * 排队
       *
       * @param  {Object} obj [description]
       * @return {[type]}     [description]
       */
  push: function (obj) {
    this._array_h.push(obj)
  },

      /**
       * 出队
       *
       * @return {Object} [description]
       */
  pop: function () {
    var ret = null
    if (this._array_h.length()) {
      ret = this._array_h.at(this._index)
      if (++this._index * 2 >= this._array_h.length()) {
        this._array_h.slice(this._index)
        this._index = 0
      }
    }
    return ret
  },

      /**
       * 返回队列中头部(即最新添加的)的动态对象
       *
       * @return {Object} [description]
       */
  head: function () {
    var ret = null, len = this._array_h.length()
    if (len) {
      ret = this._array_h.at(len - 1)
    }
    return ret
  },

      /**
       * 返回队列中尾部(即最早添加的)的动态对象
       *
       * @return {Object} [description]
       */
  tail: function () {
    var ret = null, len = this._array_h.length()
    if (len) {
      ret = this._array_h.at(this._index)
    }
    return ret
  },

      /**
       * 返回数据队列长度
       *
       * @return {Number} [description]
       */
  length: function () {
    return this._array_h.length() - this._index
  },

      /**
       * 队列是否为空
       *
       * @return {Boolean} [description]
       */
  empty: function () {
    return (this._array_h.length() === 0)
  },

  clear: function () {
    this._array_h.clear()
  }
}
export default Queue
